package com.delio.client.produccion.articulos;

import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.Loader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

public class Articulos {
	private static ArticuloServiceAsync as = GWT.create(ArticuloService.class);
	public static PagingLoader<PagingLoadResult<ModelData>> loader;
	public static ListStore<ModelData> store;
	public static ListStore<ModelData> storeCombo;
	public static ListLoader<ListLoadResult<ModelData>> loaderCombo;
	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocomplete;
	public static ListStore<BeanModel> storeAutocomplete;
	public static Integer articulo_id;
	//public static Boolean tipo;
	////////////////////////////cuando se quiere hacer separacion entre articulo e insumo///////////////////
/*	public static void getPaginate() {
		RpcProxy<PagingLoadResult<Articulo>> proxy = new RpcProxy<PagingLoadResult<Articulo>>() {

			@Override
			protected void load(Object loadConfig,
			    AsyncCallback<PagingLoadResult<Articulo>> callback) {
				as.paginateArticulo((FilterPagingLoadConfig) loadConfig,tipo, callback);  
			}  
	    };
	    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	      };  
        loader.setRemoteSort(true);  
        store = new ListStore<ModelData>(loader);
    }*/
	
	public static void getPaginate() {
		RpcProxy<PagingLoadResult<Articulo>> proxy = new RpcProxy<PagingLoadResult<Articulo>>() {

			@Override
			protected void load(Object loadConfig,
			    AsyncCallback<PagingLoadResult<Articulo>> callback) {
				as.paginateArticulo((FilterPagingLoadConfig) loadConfig, callback);  
			}  
	    };
	    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	      };  
        loader.setRemoteSort(true);  
        store = new ListStore<ModelData>(loader);
    }
	
	
	public static void  getStore(){
		
		 RpcProxy<List<Articulo>> proxy = new RpcProxy<List<Articulo>>(){
		    protected void load(Object loadConfig, AsyncCallback<List<Articulo>> callback){
			    as.ListarArticulos(callback);
			 }
		  	};
		 loaderCombo = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
		 storeCombo = new ListStore<ModelData>(loaderCombo);
		 loaderCombo.load();
	
	}
	

	public static void guardar(final Articulo a){
	 as.guardar(a, new AsyncCallback<Boolean>(){

		@Override
		public void onFailure(Throwable caught) {
			MessageBox.alert("Error", "No pudo guardar", null);			
		}

		@Override
		public void onSuccess(Boolean result) {
           if(result){
           	   MessageBox.alert("Guardado", "Se guardo Correctamente", null);     	   
           }else{
        	MessageBox.alert("Error", "No se guardo correctamente", null);
           }
			
		}
	 
	 });
 }
 
 
	public static void actualizar(Articulo a){
	 as.actualizar(a, new AsyncCallback<Boolean>(){

	   @Override
	   public void onFailure(Throwable caught) {
		   MessageBox.alert("Error", "Error en la acutalizacion", null);	 
	   }	
		 
	   public void onSuccess(Boolean result){
		 if(result){
		   MessageBox.alert("Actualizado","Se actualizo Correctamente", null); 
		 }else{
		   MessageBox.alert("Error", "No se actualizo Correctamente", null);	 
		 }
		}

	 });
 }
 
 public static void eliminar(Integer id){
	 as.eliminar(id, new AsyncCallback<Boolean>(){
		
		 @Override
		 public void onFailure(Throwable caught){
			 MessageBox.alert("Error", "Error en la Eliminacion", null);
		 }
		 
		 public void onSuccess(Boolean result){
			 if(result){
			   MessageBox.alert("Eliminado","Se elimino Correctamente", null); 
			 }else{
			   MessageBox.alert("Error", "No se elimino Correctamente", null);	 
			 } 
		 }

	 });
 }
 
 public static void autoComplete() {		
	 RpcProxy<PagingLoadResult<Articulo>> proxy = new RpcProxy<PagingLoadResult<Articulo>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<Articulo>> callback) {
			   as.paginateArticulo((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	 loaderAutocomplete = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
     loaderAutocomplete.setRemoteSort(true);        
     loaderAutocomplete.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
     storeAutocomplete = new ListStore<BeanModel>(loaderAutocomplete);
	}
}
